1
2
3
Learning Node.js Development
Learn the fundamentals of Node.js, and deploy and test Node.js
applications on the web
4
Andrew Mead
BIRMINGHAM - MUMBAI
5
Learning Node.js Development
Copyright © 2018 Packt Publishing
All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in
any form or by any means, without the prior written permission of the publisher, except in the case of brief
quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy of the information
presented. However, the information contained in this book is sold without warranty, either express or
implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any
damages caused or alleged to have been caused directly or indirectly by this book.
Packt Publishing has endeavored to provide trademark information about all of the companies and products
mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the
accuracy of this information.
Acquisition Editor:
Ben Renow-Clarke
Content Development Editor:
Monika Sangwan
Technical Editors:
Anupam Tiwari, Gaurav Gavas
Copy Editors:
Safis Editing, Tom Jacob
Project Editor:
Suzanne Coutinho
Proofreader:
Safis Editing
Indexer:
Pratik Shirodkar
Production Coordinator:
Nilesh Mohite
First published: January 2018
Production reference: 1300118
Published by Packt Publishing Ltd.
Livery Place
35 Livery Street
Birmingham
B3 2PB, UK.
ISBN 978-1-78839-554-0
www.packtpub.com
6
mapt.io
Mapt is an online digital library that gives you full access to over 5,000 books
and videos, as well as industry leading tools to help you plan your personal
development and advance your career. For more information, please visit our
website.
7
Why subscribe?
Spend less time learning and more time coding with practical eBooks and
Videos from over 4,000 industry professionals
Improve your learning with Skill Plans built especially for you
Get a free eBook or video every month
Mapt is fully searchable
Copy and paste, print, and bookmark content
8
PacktPub.com
Did you know that Packt offers eBook versions of every book published, with
PDF and ePub files available? You can upgrade to the eBook version at
www.PacktP
ub.com
and as a print book customer, you are entitled to a discount on the eBook
copy. Get in touch with us at
service@packtpub.com
for more details.
At
www.PacktPub.com
, you can also read a collection of free technical articles, sign up
for a range of free newsletters, and receive exclusive discounts and offers on
Packt books and eBooks.
9
Contributor
10
About the author
Andrew Mead
is a full-stack developer living in beautiful Philadelphia! He
launched his first Udemy course in 2014 and had a blast teaching and helping
others. Since then, he has launched 3 courses with over 21,000 students and over
1,900 5-star reviews.
Andrew currently teaches Node, Gulp, and React. Before he started teaching, he
created a web app development company. He has helped companies of all sizes
launch production web applications to their customers. He has had the honor of
working with awesome companies such as Siemens, Mixergy, and Parkloco. He
has a Computer Science degree from Temple University, and he has been
programming for just over a decade. He loves creating, programming, launching,
learning, teaching, and biking.
11
Packt is searching for authors
like you
If you're interested in becoming an author for Packt, please visit
authors.packtpub.c om
and apply today. We have worked with thousands of developers and tech
professionals, just like you, to help them share their insight with the global tech
community. You can make a general application, apply for a specific hot topic
that we are recruiting an author for, or submit your own idea.
12
Table of Contents
Preface
Who this book is for What
this book covers
To get the most out of this book Download
the example code files
Conventions used
Get in touch
Reviews
1.
Getting Set Up
Node.js installation
Node.js version confirmation
Installing Node
Verifying installation What is
Node?
Differences between JavaScript coding using Node and in the browser Why use Node
Blocking and non-blocking software development
The working of blocking I/O The
working non-blocking I/O
Blocking and non-blocking examples using Terminal Node community
– problem solving open source libraries
Different text editors for node applications
Hello World – creating and running the first Node app Creating the Node
application
Running the Node application
Summary
2.
Node Fundamentals – Part 1
Module basics
Using case for require()
Initialization of an application The
built-in module to use require()
Creating and appending files in the File System module The OS module
in require()
Concatenating user.username
Using template strings
Require own files
Making a new file to load other files Exporting files
from note.js to use in app.js
13
A simple example of the working of the exports object Exporting the
functions
14
Exercise – adding a new function to the export object
Solution to the exercise
Third-party modules
Creating projects using npm modules Installing the
lodash module in our app
Installation of lodash
Using the utilities of lodash Using the
_.isString utility Using _.uniq
The node_modules folder Global
modules
Installing the nodemon module
Executing nodemon
Getting input
Getting input from the user inside the command line
Accessing the command-line argument for the notes application Adding
if/else statements
Exercise – adding two else if clauses to an if block Solution to the
exercise
Getting the specific note information
Summary
3.
Node Fundamentals – Part 2
yargs
JSON
Installing yargs Running
yargs
Working with the add command Working with
the list command
The read command
Dealing with the errors in parsing commands The remove
command
Fetching command
Converting objects into strings
Defining a string and using in app as an object Converting a string
back to an object
Storing the string in a file
Writing the file in the playground folder Reading out the
content in the file
Adding and saving notes Adding
notes
Adding notes to the notes array Fetching
15
new notes
Trying and catching code block
16
Making the title unique
Refactoring
Moving functionality into individual functions
Working with fetchNotes
Working with saveNotes
Testing the functionality
Summary
4.
Node Fundamentals – Part 3
Removing a note
Using the removeNote function Printing a
message of removing notes
Reading note
Using the getNote function
Running the getNote function The
DRY principle
Using the logNote function
Debugging
Executing a program in debug mode Working
with debugging
Using debugger inside the notes application Listing
notes
Using the getAll function
Advanced yargs
Using chaining syntax on yargs
Calling the .help command Adding
the options object
Adding the title
Adding the body
Adding support to the read and remove commands Adding the
titleOption and bodyOption variables
Testing the remove command Arrow
functions
Using the arrow function
Exploring the difference between regular and arrow functions Exploring the
arguments array
Summary
5.
Basics of Asynchronous Programming in Node.js The basic
concept of asynchronous program
Illustrating the async programming model Call
stack and event loop
A synchronous program example
17
The call stack
Running the synchronous program
A complex synchronous program example An async
program example
18
The Node API in async programming
The callback queue in async programming The
event loop
Running the async code
Callback functions and APIs
The callback function
Creating the callback function Running the
callback function
Simulating delay using setTimeout Making
request to Geolocation API
Using Google Maps API data in our code
Installing the request package Using
request as a function Running the
request
Pretty printing objects
Using the body argument Making
up of the HTTPS requests
The response object
The error argument
Printing data from the body object Printing
the formatted address Printing latitude
and longitude
Summary
6.
Callbacks in Asynchronous Programming
Encoding user input
Installing yargs Configuring
yargs
Printing the address to screen Encoding and
decoding the strings
Encoding URI component
Decoding URI component
Pulling the address out of argv
Callback errors
Checking error in Google API request
Adding the if statement for callback errors
Adding if else statement to check body status property
Testing the body status property
Abstracting callbacks
Refactoring app.js and code into geocode.js file
Working on request statement
Creating geocode file
Adding callback function to geocodeAddress
19
Setting up the function in geocodeAddress function in app.js Implementing the
callback function in geocode.js file
20
Testing the callback function in geocode.js file Wiring up
weather search
Exploring working of API in the browser
Exploring the actual URL for code
Making a request for the weather app using the static URL Error handling
in the the callback function
Another way of error handling
Testing the error handling in callback Chaining
callbacks together
Refactoring our request call in weather.js file
Defining the new function getWeather in weather file Providing
weather directory in app.js
Passing the arguments in the getWeather function
Printing errorMessage in the getWeather function
Implementing getWeather callback inside weather.js file
Adding dynamic latitude and longitude
Changing console.log calls into callback calls Chaining the
geocodeAddress and getWeather callbacks together
Moving getWeather call into geocodeAddress function Replacing
static coordinates with dynamic coordinates Testing the chaining of
callbacks
Summary
7.
Promises in Asynchronous Programming
Introduction to ES6 promises
Creating an example promise
Calling the promise method then Running the
promise example in Terminal Error handling in
promises
Merits of promises
Advanced promises
Providing input to promises
Returning the promises Promise
chaining
Error handling in promises chaining
The catch method The
request library in promises
Testing the request library Weather
app with promises
Fetching weather app code from the app.js file Axios
documentations
Installing axios
21
Making calls in the app-promise file
Making axios request
Error handling in axios request
Error handling with ZERO_RESULT body status
22
Generating the weather URL
Chaining the promise calls
Summary
8.
Web Servers in Node
Introducing Express
Configuring Express
Express docs website
Installing Express
Creating an app
Exploring the developer tools in the browser for the app request
Passing HTML to res.send
Sending JSON data back
Error handling in the JSON request The
static server
Making an HTML page
The head tag The
body tag
Serving the HTML page in the Express app
The call to app.listen
Rendering templates
Installing the hbs module
Configuring handlebars Our
first template
Getting the static page for rendering Injecting
data inside of templates
Rendering the template for the root of the website Advanced
templates
Adding partials
Working of partial The
Header partial
The Handlebars helper
Arguments in Helper
Express Middleware
Exploring middleware
Creating a logger Printing
message to file
The maintenance middleware without the next object Testing the
maintenance middleware
Summary
9.
Deploying Applications to Web
Adding version control
Installing Git
23
Git on macOS Git
on Windows
24
Testing the installation
Turning the node-web-server directory into a Git repository Using Git
Adding untracked files to commit
Making a commit Setting
up GitHub and SSH keys
Setting up SSH keys
SSH keys documentations
Working on commands
Generating a key
Starting up the SSH agent
Configuring GitHub
Testing the configuration
Creating a new repository
Setting up the repository
Deploying the node app to the Web
Installing Heroku command-line tools
Log in to Heroku account locally Getting
SSH key to Heroku
Setting up in the application code for Heroku Changes
in the server.js file
Changes in the package.json file Making a
commit in Heroku
Running the Heroku create command
Summary
10.
Testing the Node Applications – Part 1 Basic
testing
Installing the testing module Testing
a Node project
Mocha – the testing framework
Creating a test file for the add function Creating the if
condition for the test
Testing the squaring a number function
Autorestarting the tests
Using assertion libraries in testing Node modules
Exploring assertion libraries
Chaining multiple assertions
Multiple assertions for the square function Exploring usage
of expect with bogus test
Using toBe and toNotBe to compare array/objects Using the
toEqual and toNotEqual assertions Using toInclude and
25
toExclude
Testing the setName method The
asynchronous testing
26
Creating the asyncAdd function using the setTimeout object Writing the
test for the asyncAdd function
Making assertion for the asyncAdd function
Adding the done argument
The asynchronous testing for the square function
Creating the async square function Writing
test for asyncSquare
Making assertions for the asyncSquare function
Summary
11.
Testing the Node Applications – Part 2 Testing
the Express application
Setting up testing for the Express app Testing the
Express app using SuperTest
The SuperTest documentation
Creating a test for the Express app Writing
the test for the Express app
Testing our first API request Setting
up custom status
Adding flexibility to SuperTest Creating
an express route
Writing the test for the express route
Organizing test with describe()
Adding describe() for individual methods
Adding the route describe block for the server.test.js file Test spies
Creating a test file for spies
Creating a spy
Setting up spies assertions
More details out of spy assertion Swapping
of the function with spy
Installing and setting up the rewire function Replacing db
with the spy
Writing a test to verify swapping of the function
Summary
Conclusion
Another Book You May Enjoy
Leave a review - let other readers know what you think
27
Preface
Welcome to Learning Node.js Development. This book is packed with a ton of
content, projects, challenges and real-world examples, all designed to teach you
Node by doing. This means you'll be getting your hands dirty early on in the
upcoming chapters writing some code, and you'll be writing code for every
project. You will be writing every line of code that powers our applications.
Now, we would require a text editor for this book. We have various text editor
options that you can use. I always recommend using
Atom
, which you can find
at
atom.io
. It's free, open-source, and it's available for all operating systems,
namely Linux, macOS, and Windows. It's created by the folks behind GitHub.
All the projects in the book are fun to build and they were designed to teach you
everything required to launch your own Node app, from planning to
development and testing to deploying. Now, as you launch these different Node
applications and move through the book, you will run into errors, which is bound
to happen. Maybe something doesn't get installed as expected, or maybe you try
to run an app and instead of getting the expected output, you get a really long
obscure error message. Don't worry, I am there to help. I'll show you tips and
tricks to get pass through those errors in the chapters. Let's go ahead and get to
it.
28
Who this book is for
This book targets anyone looking to launch their own Node applications, switch
careers, or freelance as a Node developer. You should have a basic understanding
of JavaScript in order to follow this book.
29
What this book covers
Chapter 1
, Getting Set Up, talks about what Node is and why you want to use it. In
this chapter, you'll learn Node installation and by the end of the chapter, you'll be
able to run your first Node application.
Chapter 2
, Node Fundamentals - Part 1, talks about building Node applications.
The Node Fundamentals topic has been divided into 3 parts. Part 1 of this topic
includes module basics, requiring own files, and third-party NPM modules.
Chapter 3
, Node Fundamentals - Part 2, continues our discussion on some more
Node fundamentals. This chapter explores yargs, JSON, the addNote function,
and refactor, moving functionality into individual functions and testing the
functionality.
Chapter 4
, Node Fundamentals - Part 3, includes things such as read and write
from the file system. We'll look into advanced yargs configuration, debugging
broken apps, and some new ES6 functions.
Chapter 5
, Basics of Asynchronous Programming in Node.js, covers basic
concepts, terms, and technologies related to the async programming, making it
super-practical and using it in our weather application.
Chapter 6
, Callbacks in Asynchronous Programming, is the second part of async
programming in Node. We'll look into callbacks, HTTPS requests, and error
handling inside of our callback functions. We'll also look into the forecast API
and fetching real-time weather data for our address.
Chapter 7
, Promises in Asynchronous Programming, is the third and last part of
async programming in Node. This chapter focuses on Promises, how it works,
why they are useful, and so on. At the end of this chapter, we'll use Promises in
our weather app.
Chapter 8
, Web Servers in Node, talks about Node web servers and integrating
version control into Node applications. We'll also introduce a framework called
Express, one of the most important NPM libraries.
30
Chapter 9
, Deploying Applications to Web, talks about deploying the applications
to the Web. We'll be using Git, GitHub, and deploy our live app to the Web using
these two services.
Chapter 10
, Testing the Node Applications- Part 1, talks about how we can test our
code to make sure it is working as expected. We'll work on setting up for testing
and then writing our test cases. We'll look into the basic testing framework and
asynchronous testing.
Chapter 11
, Testing the Node Application - Part 2, continues our journey of testing
Node applications. In this chapter, we'll work on testing the Express applications
and look into some advanced methods of testing.
31
To get the most out of this book
A web browser, we'll be using Chrome throughout the course book but any
browser will do, and Terminal, sometimes known as the command line on Linux
or the Command Prompt on Windows. Atom as the text editor. The following list
of modules will be used throughout the course of this book:
lodash
nodemon
yargs
request
axios
express
hbs
heroku
rewire
32
Download the example code files
You can download the example code files for this book from your account at
www.
packtpub.com
. If you purchased this book elsewhere, you can visit
www.packtpub.com/su pport
and register to have the files emailed directly to you.
You can download the code files by following these steps:
1.
Log in or register at
www.packtpub.com
.
2.
Select the SUPPORT tab.
3.
Click on Code Downloads & Errata.
4.
Enter the name of the book in the Search box and follow the onscreen
instructions.
Once the file is downloaded, please make sure that you unzip or extract the
folder using the latest version of:
WinRAR/7-Zip for Windows
Zipeg/iZip/UnRarX for Mac
7-Zip/PeaZip for Linux
The code bundle for the book is also hosted on GitHub at
https://github.com/PacktPu
blishing/Learning-Node.js-Development
. We also have other code bundles from our rich
catalog of books and videos available at
https://github.com/PacktPublishing/
. Check them
out!
33
Conventions used
There are a number of text conventions used throughout this book.
CodeInText
: Indicates code words in text, database table names, folder names,
filenames, file extensions, pathnames, dummy URLs, user input, and Twitter
handles. Here is an example: "Mount the downloaded
WebStorm-10*.dmg
disk image
file as another disk in your system."
A block of code is set as follows:
console.log('Starting app.js');
const fs = require('fs'); const _ =
require('lodash'); const yargs =
require('yargs');
When we wish to draw your attention to a particular part of a code block, the
relevant lines or items are set in bold:
const argv = yargs.argv;
var command = process.argv[2];
console.log('Command:', command);
console.log('Process', process.argv);
console.log('Yargs', argv);
Any command-line input or output is written as follows:
cd hello-world node
app.js
Bold
: Indicates a new term, an important word, or words that you see onscreen.
For example, words in menus or dialog boxes appear in the text like this. Here is
an example: "Select System info from the Administration panel."
Warnings or important notes appear like this.
Tips and tricks appear like this.
34
Get in touch
Feedback from our readers is always welcome.
General feedback
: Email
feedback@packtpub.com
and mention the book title in the
subject of your message. If you have questions about any aspect of this book,
please email us at
questions@packtpub.com
.
Errata
: Although we have taken every care to ensure the accuracy of our
content, mistakes do happen. If you have found a mistake in this book, we would
be grateful if you would report this to us. Please visit
www.packtpub.com/submit-errata
,
selecting your book, clicking on the Errata Submission Form link, and entering
the details.
Piracy
: If you come across any illegal copies of our works in any form on the
Internet, we would be grateful if you would provide us with the location address
or website name. Please contact us at
copyright@packtpub.com
with a link to the
material.
If you are interested in becoming an author
: If there is a topic that you have
expertise in and you are interested in either writing or contributing to a book,
please visit
authors.packtpub.com
.
35
Reviews
Please leave a review. Once you have read and used this book, why not leave a
review on the site that you purchased it from? Potential readers can then see and
use your unbiased opinion to make purchase decisions, we at Packt can
understand what you think about our products, and our authors can see your
feedback on their book. Thank you!
For more information about Packt, please visit
packtpub.com
.
36
Getting Set Up
In this chapter, you'll get your local environment set up for the rest of the book.
Whether you're on macOS, Linux, or Windows, we'll install Node and look at
exactly how we can run Node applications.
We'll talk about what Node is, why you would ever want to use it, and why you
would want to use Node as opposed to something like Rails, C++, Java, or any
other language that can accomplish similar tasks. By the end of this chapter, you
will be running your very first Node application. It's going to be simple, but it is
going to get us to the path to creating real-world production Node apps, which is
the goal of this book.
More specifically, we'll cover the following topics:
Node.js installation
What Node is
Why use Node
Atom
Hello World
37
Node.js installation
Before we start talking about what Node is and why it's useful, you need to first
install Node on your machine, because in the next couple of sections, we'll want
to run a little bit of Node code.
Now, to get started, we just need two programs—a browser, I'll be using Chrome
throughout the book, but any browser will do, and Terminal. I'll use
Spotlight
to
open up Terminal, which is what it's known as on my operating system.
If you're on Windows, look for the Command Prompt, you can search using the
Windows key and then by typing
command prompt
, and on Linux, you're looking for
the command line, although depending on your distribution it might be called
Terminal or Command Prompt.
Now, once you have that program open, you'll see a screen, as shown in the
following screenshot:
38
Essentially, it's waiting for you to run a command. We'll run quite a few
commands from Terminal throughout the book. I'll discuss it in a few sections
later, so if you've never used this before, you can start navigating comfortably.
39
Node.js version confirmation
In the browser, we can head over to
nodejs.org
to grab the installer for the latest
version of Node(as shown here). In this book, we'll use the most recent version,
version 9.3.0:
It is important that you install a V8 version of Node.js. It doesn't
have to be 4.0, it could be 1.0, but it is important it's on that V8
branch, because there is a ton of new features that come along with
V8, including all of the features you might have come to love in the
browser using ES6.
ES6 is the next version of JavaScript and it comes with a lot of great
enhancements we'll be using throughout the book. If you look at the following
image, Node.js Long Term Support Release Schedule (
https://github.com/nodejs/LTS
),
you can see that the current Node version is V8, out in April 2017:
40
Before going further, I would like to talk about the Node release cycle. What I
have in the preceding image is the official release cycle, this is released by Node.
You'll notice that only next to the even Node numbers do you find the active
LTS, the blue bar, and the maintenance bar. Now, LTS stands for long-term
support, and this is the version that's recommended for most users. I'd
recommend that you stick with the currently offered LTS option (Node v 8.9.4
LTS), though anything on the left-hand side will do, this is shown as the two
green buttons on
nodejs.org
.
Now, as you can see, the major version numbers, bump every six months.
Regardless of any sort of big overarching change, this happens like clockwork
even if nothing drastic has changed. It's not like Angular where jumping from
1.0 to 2.0 was almost like using a completely different library. This is just not the
case with Node, what you're getting from this book is the latest and greatest
Node has to offer.
41
Installing Node
Once the version is confirmed and selected, all we have to do is to click the
required version button on the Node website (
nodejs.org
) and download the
installer. The installer is one of those basic click Next a few times and you're
done type of installers, there's no need to run any fancy commands. I'll start the
installer. As shown in the following screenshot, it'll just ask a few questions, then
let's click on Next or Continue through all of them:
You might want to specify a custom destination, but if you don't know what that
means, and you don't usually do it when installing programs, skip that step too.
Here, in the next screenshot, you can see that I'm using just 58.6 MB, no
problem.
I'll run the installer by entering my password. And once I enter my password, it
should really only take a couple of seconds to get Node installed:
42
As shown in the following screenshot, we have a message that says The
installation was completed successfully, which means we are good to go:
43
Verifying installation
Now that Node has been installed successfully, we can go ahead and verify that
by running Node from Terminal. Inside Terminal, I'll shut it down by going to
Quit Terminal and open it up again:
The reason I'm opening it up is because we've installed a new
command, and some Terminals require a restart before they will be
able to run that new command.
In our case, we restarted things and we can run our brand new command so,
we'll type it:
node -v
What we're doing in this command is we're running the Node command, and
we're passing in what's called a
flag
, a hyphen sign followed by a letter. It could
be
a
, it could be
j
, or in our case it's
v
. This command will print the version of
44
Node currently installed.
We might get an error like this:
If you try to run a command that doesn't exist, such as
nodeasdf
, you'll see
command not found. If you see this, it usually means the Node installer didn't
work correctly, or you haven't run it in the first place.
In our case though, running Node with the
v
flag should result in a number. In
our case, it's version 9.3.0. If you do have Node installed, and you see something
like the following screenshot, then you are done. In the next section, we'll start
exploring exactly what Node is.
45
46
What is Node?
Node came about when the original developers took JavaScript, something you
could usually only run inside the browser, and they let it run on your machine as
a standalone process. This means that we could create applications using
JavaScript outside the context of the browser.
Now, JavaScript previously had a limited feature set. When I used it in the
browser, I could do things such as update the URL and remove the Node logo,
adding click events or anything else, but I couldn't really do much more.
With Node, we now have a feature set that looks much more similar to other
languages, such as Java, Python, or PHP. Some of these are as follows:
We can write Node applications using the JavaScript syntax
You can manipulate your filesystem, creating and removing folders
You can create query databases directly
You can even create web servers using Node
These were things that were not possible in the past, and they are because of
Node.
Now, both Node and the JavaScript that gets executed inside of your browser,
they're both running on the exact same engine. It's called the V8 JavaScript
runtime engine. It's an open source engine that takes JavaScript code and
compiles it into much faster machine code. And that's a big part of what makes
Node.js so fast.
Machine code is low-level code that your computer can run directly without
needing to interpret it. Your machine only knows how to run certain types of
code, for example, your machine can't run JavaScript code or PHP code directly
without first converting it into low-level code.
Using this V8 engine, we can take our JavaScript code, compile it to much
quicker machine code, and execute that. This is where all those new features
come in. The V8 engine is written in a language called C++. So if you want to
47
extend the Node language, you don't write Node code, you write C++ code that
builds off of what V8 already has in place.
Now, we'll not be writing any C++ code in this book. This book is
not about adding onto Node, it is about using Node. So, we will
only be writing JavaScript code.
Speaking of JavaScript code, let's start writing some inside Terminal. Now,
throughout the book, we'll be creating files and executing those files, but we can
actually create a brand new Node process by running the
node
command.
Referring to the following screenshot, I have a little right caret, which is waiting
for JavaScript Node code, not a new command-prompt command:
This means that I can run something like
console.log
, which, as you probably
already know, logs a message to the screen.
log
is a function, so I'll call it as
such, opening and closing my parentheses, and passing in a string inside two
single quotes, a message
Hello world!,
as shown in the following command line:
console.log('Hello world!');
48
This will print Hello world to the screen. If I hit enter, Hello world! prints just
like you'd expect, as shown in the following code output:
Now, what actually happened behind the scenes? Well, this is what Node does. It
takes your JavaScript code, it compiles it into machine code, and executes it. In
the preceding code, you can see it executed our code, printing out Hello world!.
Now, the V8 engine is running behind the scenes when we execute this
command, and it's also running inside the Chrome browser.
If I open up the developer tools in Chrome by going to Settings | More Tools |
Developer Tools:
49
I can ignore most of the things. I'm just looking for the Console tab, as shown in
the following screenshot:
50